{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = r'D:\\Users\\VonBrank\\Documents\\GitHub\\code-learning\\algorithm\\deep-learning\\computer-visualization\\cs231n\\datasets\\cifar-10-batches-py'\n",
    "\n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.436469\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -1.411860 analytic: -1.411860, relative error: 4.234221e-09\n",
      "numerical: -2.099443 analytic: -2.099443, relative error: 1.668572e-08\n",
      "numerical: 0.482931 analytic: 0.482931, relative error: 2.480039e-07\n",
      "numerical: -3.140410 analytic: -3.140411, relative error: 4.057090e-08\n",
      "numerical: 0.802777 analytic: 0.802777, relative error: 1.077436e-07\n",
      "numerical: 0.313764 analytic: 0.313764, relative error: 2.979908e-07\n",
      "numerical: 2.231381 analytic: 2.231381, relative error: 2.773670e-08\n",
      "numerical: -3.821632 analytic: -3.821632, relative error: 8.411234e-09\n",
      "numerical: 1.305570 analytic: 1.305570, relative error: 3.987604e-08\n",
      "numerical: 4.775201 analytic: 4.775201, relative error: 5.476744e-09\n",
      "numerical: -0.143835 analytic: -0.143836, relative error: 1.638888e-07\n",
      "numerical: 1.562779 analytic: 1.562779, relative error: 8.748645e-09\n",
      "numerical: 0.356468 analytic: 0.356468, relative error: 8.399728e-08\n",
      "numerical: -4.849826 analytic: -4.849826, relative error: 9.157401e-09\n",
      "numerical: 4.683174 analytic: 4.683174, relative error: 1.585304e-08\n",
      "numerical: 0.056209 analytic: 0.056209, relative error: 1.948904e-07\n",
      "numerical: 0.292811 analytic: 0.292811, relative error: 8.000633e-08\n",
      "numerical: 1.149924 analytic: 1.149924, relative error: 2.992340e-08\n",
      "numerical: 6.481767 analytic: 6.481767, relative error: 8.616142e-09\n",
      "numerical: -3.913832 analytic: -3.913832, relative error: 3.624179e-08\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.436469e+00 computed in 0.212255s\n",
      "vectorized loss: 2.436469e+00 computed in 0.002993s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "tuning",
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.347714 val accuracy: 0.370000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.325837 val accuracy: 0.343000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.349633 val accuracy: 0.363000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.318592 val accuracy: 0.328000\n",
      "best validation accuracy achieved during cross-validation: 0.370000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        loss_history = softmax.train(X_train, y_train, lr, reg,\n",
    "                      num_iters=1500, verbose=False)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        train_accuracy = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        val_accuracy = np.mean(y_val == y_val_pred)\n",
    "        results[(lr, reg)] = train_accuracy, val_accuracy\n",
    "        if val_accuracy > best_val:\n",
    "            best_val = val_accuracy\n",
    "            best_softmax = softmax\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.357000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
